// dictationManager.js - 听写状态管理器
// 提供单例模式的听写状态管理器
let instance = null;

class DictationManager {
  constructor() {
    // 初始化状态
    this.state = {
      // 听写状态
      isLoading: true, // 加载状态
      isDictating: false, // 是否正在听写
      isSelectingSource: false, // 是否正在选择词库和分组
      showDictationResult: false, // 是否显示听写结果
      isAnswerCorrect: undefined, // 当前答案是否正确
      
      // 单词数据
      wordsForDictation: [], // 用于听写的单词列表
      currentWordIndex: 0, // 当前单词索引
      currentWord: null, // 当前单词
      totalWordsCount: 0, // 总单词数
      
      // 听写模式
      dictationModes: [
        { id: 'en_to_zh', name: '听英文写中文' },
        { id: 'zh_to_en', name: '听中文写英文' },
        { id: 'random', name: '随机' }
      ],
      selectedMode: 'en_to_zh', // 默认模式
      currentMode: 'en_to_zh', // 当前使用的模式
      
      // 答题模式
      answeringMode: 'online', // 默认线上答题模式
      
      // 作答时间设置
      timeLimitEnabled: false, // 是否启用时间限制
      timeLimit: 30, // 默认时间限制（秒）
      timeRemaining: 0, // 剩余时间（秒）
      
      // 用户输入
      userInput: '', // 用户输入的内容
      
      // 词库和分组
      books: [], // 词库列表
      groups: [], // 分组列表
      selectedBookId: '', // 选中的词库ID
      selectedGroup: '', // 选中的分组名称
      
      // 统计信息
      correctCount: 0, // 正确数量
      wrongCount: 0, // 错误数量
      
      // 音频设置
      pronunciationType: 'american',
      playbackSpeed: 1.0,
      isPlaying: false,
      
      // 动画效果
      answerAnimation: null
    };
    
    // 计时器实例
    this.timerInterval = null;
    
    // 事件监听器列表
    this.listeners = [];
    
    // 获取全局应用实例
    this.app = getApp();
  }

  /**
   * 获取听写管理器的单例实例
   * @returns {DictationManager} 听写管理器实例
   */
  static getInstance() {
    if (!instance) {
      instance = new DictationManager();
    }
    return instance;
  }

  /**
   * 初始化听写管理器
   * @param {WordDataManager} wordDataManager - 单词数据管理器实例
   * @param {ReviewScheduler} reviewScheduler - 复习计划管理器实例
   * @param {AudioManager} audioManager - 音频管理器实例
   */
  initialize(wordDataManager, reviewScheduler, audioManager) {
    this.wordDataManager = wordDataManager;
    this.reviewScheduler = reviewScheduler;
    this.audioManager = audioManager;
  }
  
  // 获取当前状态
  getState() {
    return { ...this.state };
  }
  
  // 更新状态
  setState(newState) {
    this.state = { ...this.state, ...newState };
    this.notifyListeners();
  }
  
  // 添加状态变化监听器
  addListener(listener) {
    this.listeners.push(listener);
  }
  
  // 移除状态变化监听器
  removeListener(listener) {
    this.listeners = this.listeners.filter(l => l !== listener);
  }
  
  // 通知所有监听器状态变化
  notifyListeners() {
    const currentState = this.getState();
    this.listeners.forEach(listener => {
      try {
        listener(currentState);
      } catch (error) {
        console.error('状态变化监听器执行错误:', error);
      }
    });
  }
  
  // 初始化音频管理器
  initAudioManager() {
    this.audioManager.addStatusChangeCallback(this.onAudioStatusChange.bind(this));
  }
  
  // 音频状态变化回调函数
  onAudioStatusChange(status) {
    this.setState({
      isPlaying: status.isPlaying
    });
  }
  
  // 加载发音设置
  loadPronunciationSettings() {
    try {
      const pronunciationType = this.wordDataManager.getPronunciationType();
      const playbackSpeed = this.wordDataManager.getPlaybackSpeed();
      
      this.setState({
        pronunciationType: pronunciationType || 'american',
        playbackSpeed: playbackSpeed || 1.0
      });
    } catch (error) {
      console.error('加载发音设置失败:', error);
    }
  }
  
  // 加载需要复习的单词
  async loadReviewWords() {
    this.setState({ isLoading: true });
    
    try {
      // 获取所有需要复习的单词
      const wordsForReview = this.reviewScheduler.getWordsForReview();
      
      if (wordsForReview.length === 0) {
        wx.showToast({
          title: '没有需要复习的单词',
          icon: 'none'
        });
        setTimeout(() => {
          wx.navigateBack();
        }, 2000);
        return;
      }
      
      // 打乱单词顺序
      const shuffledWords = this._shuffleArray([...wordsForReview]);
      
      this.setState({
        wordsForDictation: shuffledWords,
        totalWordsCount: shuffledWords.length,
        currentWordIndex: 0,
        currentWord: shuffledWords[0],
        isLoading: false,
        isDictating: true,
        currentMode: this.state.selectedMode
      });
      
      // 自动播放第一个单词
      setTimeout(() => {
        this.playCurrentWord();
      }, 500);
    } catch (error) {
      console.error('加载复习单词失败:', error);
      wx.showToast({
        title: '加载失败，请重试',
        icon: 'none'
      });
      this.setState({ isLoading: false });
    }
  }
  
  // 加载词库和分组
  async loadBooksAndGroups() {
    this.setState({ isLoading: true });
    
    try {
      // 获取所有词库
      const books = this.wordDataManager.getAllBooks();
      
      // 初始化分组为空
      const groups = [];
      
      this.setState({
        books,
        groups,
        isLoading: false,
        isSelectingSource: true
      });
    } catch (error) {
      console.error('加载词库失败:', error);
      wx.showToast({
        title: '加载失败，请重试',
        icon: 'none'
      });
      this.setState({ isLoading: false });
    }
  }
  
  // 从所选词库的单词中提取分组
  async loadGroupsFromSelectedBook(bookId) {
    try {
      // 获取所选词库的所有单词
      const words = this.wordDataManager.getWordsByBookId(bookId);
      
      // 提取所有单词中的分组，根据词书id过滤
      const groupsSet = new Set();
      words.forEach(word => {
        if (word.groups && Array.isArray(word.groups)) {
          word.groups.forEach(group => {
            // 检查分组是否以当前词书id开头
            if (group.startsWith(`${bookId}-`)) {
              // 只添加分组名称部分，去掉词书id前缀
              const groupName = group.substring(bookId.length + 1);
              groupsSet.add(groupName);
            }
          });
        }
      });
      
      // 转换为数组并进行自然排序（包含数字时按数字大小排序）
      const groups = Array.from(groupsSet).sort((a, b) => {
        // 自然排序函数，能够正确处理包含数字的字符串
        const aNum = parseInt(a.match(/\d+/)?.[0]);
        const bNum = parseInt(b.match(/\d+/)?.[0]);
        
        // 如果两个字符串都包含数字，则按数字排序
        if (!isNaN(aNum) && !isNaN(bNum)) {
          return aNum - bNum;
        }
        // 如果只有一个包含数字，则包含数字的排前面
        if (!isNaN(aNum)) return -1;
        if (!isNaN(bNum)) return 1;
        // 如果都不包含数字，则按字符串默认排序
        return a.localeCompare(b);
      });
      
      this.setState({
        groups
      });
      
      return Promise.resolve();
    } catch (error) {
      console.error('加载分组失败:', error);
      wx.showToast({
        title: '加载分组失败',
        icon: 'none'
      });
      return Promise.resolve();
    }
  }
  
  // 开始听写
  async startDictation(bookId, group, mode) {
    if (!bookId) {
      wx.showToast({
        title: '请选择词库',
        icon: 'none'
      });
      return;
    }
    
    this.setState({ isLoading: true });
    
    try {
      let words = [];
      
      // 获取所选词库的所有单词
      words = this.wordDataManager.getWordsByBookId(bookId);
      
      // 如果选择了分组，则过滤出该分组的单词
      // 这里的group应该已经包含词书id前缀
      if (group) {
        words = words.filter(word => 
          word.groups && word.groups.includes(group)
        );
      }
      
      if (words.length === 0) {
        wx.showToast({
          title: '选择的词库或分组中没有单词',
          icon: 'none'
        });
        this.setState({ isLoading: false });
        return;
      }
      
      // 打乱单词顺序
      const shuffledWords = this._shuffleArray([...words]);
      
      // 根据选择的模式确定当前模式
      let currentMode = mode;
      if (currentMode === 'random') {
        // 随机选择模式
        currentMode = Math.random() > 0.5 ? 'en_to_zh' : 'zh_to_en';
      }
      
      this.setState({
        wordsForDictation: shuffledWords,
        totalWordsCount: shuffledWords.length,
        currentWordIndex: 0,
        currentWord: shuffledWords[0],
        isLoading: false,
        isDictating: true,
        isSelectingSource: false,
        currentMode: currentMode,
        selectedBookId: bookId,
        selectedGroup: group,
        selectedMode: mode,
        timeRemaining: this.state.timeLimit // 重置剩余时间
      });
      
      // 自动播放第一个单词
      setTimeout(() => {
        this.playCurrentWord();
        // 如果启用了时间限制，开始计时
        if (this.state.timeLimitEnabled) {
          this.startTimer();
        }
      }, 500);
    } catch (error) {
      console.error('开始听写失败:', error);
      wx.showToast({
        title: '加载失败，请重试',
        icon: 'none'
      });
      this.setState({ isLoading: false });
    }
  }
  
  // 播放当前单词
  playCurrentWord() {
    const { currentWord, currentMode, pronunciationType, playbackSpeed } = this.state;
    
    if (!currentWord) {
      wx.showToast({
        title: '当前没有单词可播放',
        icon: 'none'
      });
      return;
    }
    
    // 直接播放单词，单词丰富逻辑已在audioManager.playPronunciation中封装
    this._playWordAudio(currentWord, currentMode, pronunciationType, playbackSpeed);
  }
  
  /**
   * 播放单词音频的内部方法
   * @private
   */
  _playWordAudio(word, mode, pronunciationType, playbackSpeed) {
    // 初始化音频管理器
    this.initAudioManager();
    
    // 根据当前模式确定播放内容
    if (mode === 'en_to_zh') {
      // 现在直接传入单词对象，让audioManager内部处理音频URL获取和错误处理
      this.audioManager.playPronunciation(word, playbackSpeed, pronunciationType)
        .then(() => {
          this.updateAudioStatus();
        })
        .catch(error => {
          console.error('播放失败:', error);
          wx.showToast({
            title: '播放失败',
            icon: 'none'
          });
        });
    } else if (mode === 'zh_to_en') {
      // 听中文写英文：使用语音合成播放中文释义
      const chineseText = word.chinese || '';
      if (chineseText) {
        this.audioManager.playTextToSpeech(chineseText, playbackSpeed, 'zh')
          .then(() => {
            this.updateAudioStatus();
          })
          .catch(error => {
            console.error('语音合成播放失败:', error);
            // 降级处理：如果语音合成失败，显示toast
            wx.showToast({
              title: '中文提示: ' + chineseText,
              icon: 'none',
              duration: 2000
            });
          });
      } else {
        wx.showToast({
          title: '中文释义不存在',
          icon: 'none'
        });
      }
    }
  }
  
  // 更新音频状态
  updateAudioStatus() {
    const status = this.audioManager.getStatus();
    this.setState({
      isPlaying: status.isPlaying
    });
  }
  
  // 停止发音播放
  stopPronunciation() {
    this.initAudioManager();
    this.audioManager.stopPronunciation();
    this.updateAudioStatus();
  }
  
  // 开始倒计时计时器
  startTimer() {
    if (this.timerInterval) {
      clearInterval(this.timerInterval);
    }
    
    this.timerInterval = setInterval(() => {
      const { timeRemaining, isDictating } = this.state;
      
      if (!isDictating) {
        this.stopTimer();
        return;
      }
      
      if (timeRemaining > 0) {
        this.setState({ timeRemaining: timeRemaining - 1 });
      } else {
        // 时间到了，自动进入下一题（如果是线下模式）或提示用户
        this.stopTimer();
        
        if (this.state.answeringMode === 'offline') {
          this.nextWord();
        } else {
          wx.showToast({
            title: '时间到',
            icon: 'none'
          });
        }
      }
    }, 1000);
  }
  
  // 停止倒计时计时器
  stopTimer() {
    if (this.timerInterval) {
      clearInterval(this.timerInterval);
      this.timerInterval = null;
    }
  }
  
  // 进入下一个单词
  nextWord() {
    const { currentWordIndex, totalWordsCount, currentMode } = this.state;
    
    if (currentWordIndex < totalWordsCount - 1) {
      // 进入下一个单词
      const nextIndex = currentWordIndex + 1;
      const nextWord = this.state.wordsForDictation[nextIndex];
      
      // 如果是随机模式，为下一个单词随机选择模式
      let nextMode = this.state.selectedMode;
      if (nextMode === 'random') {
        nextMode = Math.random() > 0.5 ? 'en_to_zh' : 'zh_to_en';
      }
      
      this.setState({
        currentWordIndex: nextIndex,
        currentWord: nextWord,
        currentMode: nextMode,
        userInput: '',
        isAnswerCorrect: null,
        timeRemaining: this.state.timeLimit // 重置剩余时间
      });
      
      // 自动播放下一个单词
      setTimeout(() => {
        this.playCurrentWord();
        // 如果启用了时间限制，开始计时
        if (this.state.timeLimitEnabled) {
          this.startTimer();
        }
      }, 500);
    } else {
      // 已经是最后一个单词，显示听写结果
      this.setState({
        isDictating: false,
        showDictationResult: true
      });
      
      // 停止计时器
      this.stopTimer();
    }
  }
  
  // 设置答题时间限制
  setTimeLimit(enabled, limit) {
    this.setState({
      timeLimitEnabled: enabled,
      timeLimit: limit,
      timeRemaining: enabled ? limit : 0
    });
  }
  
  // 设置答题模式（线上或线下）
  setAnsweringMode(mode) {
    this.setState({
      answeringMode: mode
    });
  }
  
  // 结束听写
  endDictation() {
    this.setState({
      isDictating: false,
      showDictationResult: true
    });
    
    // 停止计时器
    this.stopTimer();
  }
  
  // 提交答案
  submitAnswer(userInput) {
    const { answeringMode } = this.state;
    
    // 如果是线下模式，无需校验答案
    if (answeringMode === 'offline') {
      // 自动认为答案正确（实际不校验）
      const { currentWordIndex, totalWordsCount, correctCount } = this.state;
      
      this.setState({
        correctCount: correctCount + 1,
        userInput: userInput.trim()
      });
      
      // 延迟进入下一个单词或显示结果
      setTimeout(() => {
        if (currentWordIndex < totalWordsCount - 1) {
          this.nextWord();
        } else {
          // 显示听写结果
          this.setState({
            isDictating: false,
            showDictationResult: true
          });
          
          // 停止计时器
          this.stopTimer();
        }
      }, 1000);
      
      return;
    }
    
    // 线上模式
    if (!userInput.trim()) {
      wx.showToast({
        title: '请输入答案',
        icon: 'none'
      });
      return;
    }
    
    const { currentWord, currentMode, currentWordIndex, totalWordsCount, correctCount, wrongCount } = this.state;
    
    // 检查答案是否正确
    let isCorrect = false;
    if (currentMode === 'en_to_zh') {
      // 听英文写中文
      isCorrect = this._checkChineseAnswer(userInput.trim(), currentWord.chinese);
    } else if (currentMode === 'zh_to_en') {
      // 听中文写英文
      isCorrect = this._checkEnglishAnswer(userInput.trim(), currentWord.english);
    }
    
    // 更新统计信息
    const newCorrectCount = isCorrect ? correctCount + 1 : correctCount;
    const newWrongCount = isCorrect ? wrongCount : wrongCount + 1;
    
    // 记录学习结果
    if (isCorrect) {
      try {
        this.reviewScheduler.recordReviewResult(currentWord.id, true, 'normal');
      } catch (error) {
        console.error('记录学习结果失败:', error);
      }
    }
    
    // 停止计时器
      this.stopTimer();
      
      // 创建答案动画
    this._createAnswerAnimation(isCorrect);
    
    // 延迟进入下一个单词或显示结果
    setTimeout(() => {
      if (currentWordIndex < totalWordsCount - 1) {
        // 进入下一个单词
        const nextIndex = currentWordIndex + 1;
        const nextWord = this.state.wordsForDictation[nextIndex];
        
        // 如果是随机模式，为下一个单词随机选择模式
        let nextMode = this.state.selectedMode;
        if (nextMode === 'random') {
          nextMode = Math.random() > 0.5 ? 'en_to_zh' : 'zh_to_en';
        }
        
        this.setState({
          currentWordIndex: nextIndex,
          currentWord: nextWord,
          currentMode: nextMode,
          userInput: '',
          showDictationResult: false,
          correctCount: newCorrectCount,
          wrongCount: newWrongCount,
          isAnswerCorrect: null // 重置答案反馈状态，使用null替代undefined
        });
        
        // 自动播放下一个单词
        setTimeout(() => {
          this.playCurrentWord();
        }, 1000);
      } else {
        // 显示听写结果
        this.setState({
          isDictating: false,
          showDictationResult: true,
          correctCount: newCorrectCount,
          wrongCount: newWrongCount
        });
      }
    }, 1500);
  }
  
  // 重新开始听写
  restartDictation() {
    this.setState({
      userInput: '',
      currentWordIndex: 0,
      currentWord: this.state.wordsForDictation[0],
      correctCount: 0,
      wrongCount: 0,
      isDictating: true,
      showDictationResult: false
    });
    
    // 自动播放第一个单词
    setTimeout(() => {
      this.playCurrentWord();
    }, 500);
  }
  
  // 重新选择词库和分组
  reselectSource() {
    this.setState({
      isSelectingSource: true,
      showDictationResult: false,
      selectedBookId: '',
      selectedGroup: ''
    });
    this.loadBooksAndGroups();
  }
  
  // 检查中文答案
  _checkChineseAnswer(userInput, correctAnswer) {
    // 简单的实现，实际项目中可能需要更复杂的匹配算法
    return userInput.includes(correctAnswer) || correctAnswer.includes(userInput);
  }
  
  // 检查英文答案
  _checkEnglishAnswer(userInput, correctAnswer) {
    // 简单的实现，不区分大小写
    return userInput.toLowerCase() === correctAnswer.toLowerCase();
  }
  
  // 创建答案动画
  _createAnswerAnimation(isCorrect) {
    // 创建动画效果
    const animation = wx.createAnimation({
      duration: 300,
      timingFunction: 'ease',
    });
    
    animation.scale(1.1).opacity(0.8).step().scale(1).opacity(1).step();
    
    this.setState({
      answerAnimation: animation.export(),
      isAnswerCorrect: isCorrect
    });
    
    // 播放音效
    const audioUtils = require('../utils/audioUtils.js');
    audioUtils.playSound(isCorrect ? 'right' : 'wrong');
  }
  
  // 随机打乱数组
  _shuffleArray(array) {
    for (let i = array.length - 1; i > 0; i--) {
      const j = Math.floor(Math.random() * (i + 1));
      [array[i], array[j]] = [array[j], array[i]];
    }
    return array;
  }
  
  // 清理资源
  cleanup() {
    // 移除音频状态变化回调
    if (this.audioManager) {
      this.audioManager.removeStatusChangeCallback(this.onAudioStatusChange.bind(this));
    }
    // 停止计时器
    this.stopTimer();
  }
  
  // 重置状态到初始值
  resetState() {
    // 停止计时器
    this.stopTimer();
    
    const initialState = {
      // 听写状态
      isLoading: true, // 加载状态
      isDictating: false, // 是否正在听写
      isSelectingSource: false, // 是否正在选择词库和分组
      showDictationResult: false, // 是否显示听写结果
      isAnswerCorrect: undefined, // 当前答案是否正确
      
      // 单词数据
      wordsForDictation: [], // 用于听写的单词列表
      currentWordIndex: 0, // 当前单词索引
      currentWord: null, // 当前单词
      totalWordsCount: 0, // 总单词数
      
      // 听写模式
      selectedMode: 'en_to_zh', // 默认模式
      currentMode: 'en_to_zh', // 当前使用的模式
      
      // 答题模式
      answeringMode: 'online', // 默认线上答题模式
      
      // 作答时间设置
      timeLimitEnabled: false, // 是否启用时间限制
      timeLimit: 30, // 默认时间限制（秒）
      timeRemaining: 0, // 剩余时间（秒）
      
      // 用户输入
      userInput: '', // 用户输入的内容
      
      // 词库和分组
      books: [], // 词库列表
      groups: [], // 分组列表
      selectedBookId: '', // 选中的词库ID
      selectedGroup: '', // 选中的分组名称
      
      // 统计信息
      correctCount: 0, // 正确数量
      wrongCount: 0, // 错误数量
      
      // 音频设置
      isPlaying: false,
      
      // 动画效果
      answerAnimation: null
    };
    
    // 保留发音设置
    initialState.pronunciationType = this.state.pronunciationType;
    initialState.playbackSpeed = this.state.playbackSpeed;
    
    // 保留听写模式列表
    initialState.dictationModes = this.state.dictationModes;
    
    this.state = initialState;
    this.notifyListeners();
  }
}

// 导出类和单例实例
module.exports = {
  DictationManager,
  // 直接导出单例实例
  getInstance: DictationManager.getInstance
};

// 同时设置默认导出为单例实例
module.exports.default = DictationManager.getInstance();
